Scikit-learn

• Popular biblioteca de machine learning para Python;

• Vasto conjunto de algoritmos para processamento de dados e construção de modelos;

• Consistente, eficiente e de fácil utilização;

• Excelente documentação, repleta de exemplos e tutoriais.

Pré-processamento

• Seleção, transformação, criação de variáveis;

• Codificação de dados categorizados nominais e ordinais;

• Redução de dimensionalidade (PCA, FA etc.);

• Imputação de dados faltantes;

• Manipulação de dados em texto.

• etc.

Modelos

• Regressão: linear, ridge, LASSO, SVR etc;
• Classificação: regressão logística, árvore de decisão, SVM, naive Bayes, LDA/QDA etc;
• Clusterização: K-Means, misturas gaussianas etc;
• Outros:

  • Estimação de densidades de probabilidade;

  • Decomposição de sinais;

  • Detecção de anomalias;

  • Redes neurais.

Avaliação e seleção de modelos

• Particionamento dos dados em treino-teste;

• Métricas gerais de performance;

• Estimação de hiperparâmetros;

• Validação cruzada.

Preparação

• O primeiro passo é carregar o pacote reticulate e indicar onde serão executados os códigos Python; nesse caso, no ambiente virtual “venv”.

library(reticulate)
use_virtualenv("venv", required=TRUE)

• Caso precise criar esse ambiente virtual, primeiro execute:

use_python("C:/Users/user/anaconda3")
virtualenv_create("venv",
                  packages=c("scikit-learn",
                             "numpy", "pandas"))

Exemplo: classificação de tumores de mama

library(readr)
breast_cancer <- read_csv("./capitulos/scikit-learn/breast_cancer.csv")

head(breast_cancer)

# A tibble: 6 x 31
  `mean radius` `mean texture` `mean perimeter` `mean area` `mean smoothness`
          <dbl>          <dbl>            <dbl>       <dbl>             <dbl>
1          18.0           10.4            123.        1001             0.118 
2          20.6           17.8            133.        1326             0.0847
3          19.7           21.2            130         1203             0.110 
4          11.4           20.4             77.6        386.            0.142 
5          20.3           14.3            135.        1297             0.100 
6          12.4           15.7             82.6        477.            0.128 
# ... with 26 more variables: mean compactness <dbl>, mean concavity <dbl>,
#   mean concave points <dbl>, mean symmetry <dbl>,
#   mean fractal dimension <dbl>, radius error <dbl>, texture error <dbl>,
#   perimeter error <dbl>, area error <dbl>, smoothness error <dbl>,
#   compactness error <dbl>, concavity error <dbl>, concave points error <dbl>,
#   symmetry error <dbl>, fractal dimension error <dbl>, worst radius <dbl>,
#   worst texture <dbl>, worst perimeter <dbl>, worst area <dbl>, ...

• O objetivo é identificar se um tumor é maligno (câncer de mama) ou benigno.

No scikit-learn, para ajustar um modelo é preciso separar covariáveis, representadas pela data frame X, e variável resposta y.

library(dplyr)
X <- select(breast_cancer, -y)
y <- select(breast_cancer, y) # 0 = maligno, 1 = benigno

Divisão em treino e teste

• No contexto de machine learning, é rotineiro separar uma parte dos dados para testar a capacidade de um modelo, geralmente, 20% das observações. Isso pode ser feito do seguinte modo no sklearn:

model_sel <- import("sklearn.model_selection")

py_set_seed(42)
split <- model_sel$train_test_split(X, y, test_size=0.20)

X_train <- split[[1]]; X_test <- split[[2]]
y_train <- split[[3]]; y_test <- split[[4]]

A função py_set_seed fixa a semente dos geradores de números aleatórios do Python para a reprodução de resultados.

O modelo de classificação

• Um possível modelo consiste na padronização das variáveis, seguida da retenção dos cinco componentes principais de maior variação e sobre eles um Support Vector Machine.

pipe <- import("sklearn.pipeline")
preproc <- import("sklearn.preprocessing")
decomp <- import("sklearn.decomposition")
svm <- import("sklearn.svm")

model <- pipe$make_pipeline(
  preproc$StandardScaler(),         # Padronização
  decomp$PCA(n_components=5L),      # Componentes principais
  svm$LinearSVC(C=8.71, dual=FALSE) # Support Vector Machine
)

• O pipeline é análogo ao pipe %>% do R:

  • Sequência de transformações, seguida de um modelo;

  • Unifica e simplifica as etapas de pré-processamento, estimação e ajuste de hiperparâmetros, e previsões.

Ajuste do modelo

• Os hiperparâmetros n_components e C definidos podem ser ajustados utilizando métodos de validação cruzada (Grid Search, Random Search etc.) sobre o pipeline.

• Com os hiperparâmetros definidos, ajusta-se o modelo aos dados de treino.

model$fit(X_train, y_train)

• (Vazamento de dados). O pipeline ajuda a reforçar o uso de apenas os dados de treino para o ajuste.

Performance do modelo

• Agora, a verificação da qualidade das previsões por meio da acurácia no conjunto de teste.

metrics <- import("sklearn.metrics")
y_pred_test <- model$predict(X_test)

metrics$accuracy_score(y_test, y_pred_test)

[1] 0.9824561

• O scikit-learn dispõe de outras métricas de performance para modelos de classificação, tais como: acurácia balanceada, precisão, recall, F1 etc.

• Como estamos num ambiente R, podemos usar de forma natural o ggplot2 e fazer uma comparação gráfica entre o que foi observado e as previsões.

test_data <- X_test
test_data["y"] <- y_test
test_data["y_pred"] <- y_pred_test

library(ggplot2)
ggplot(data=test_data, aes(x=y_pred, y=y))+
  geom_jitter()